/**
 * <copyright>
 * </copyright>
 *
 * $Id$
 */
package org.hl7.v3.util;

import org.eclipse.emf.common.notify.Adapter;
import org.eclipse.emf.common.notify.Notifier;

import org.eclipse.emf.common.notify.impl.AdapterFactoryImpl;

import org.eclipse.emf.ecore.EObject;

import org.hl7.v3.*;

/**
 * <!-- begin-user-doc -->
 * The <b>Adapter Factory</b> for the model.
 * It provides an adapter <code>createXXX</code> method for each class of the model.
 * <!-- end-user-doc -->
 * @see org.hl7.v3.V3Package
 * @generated
 */
public class V3AdapterFactory extends AdapterFactoryImpl {
	/**
	 * The cached model package.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 */
	protected static V3Package modelPackage;

	/**
	 * Creates an instance of the adapter factory.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 */
	public V3AdapterFactory() {
		if (modelPackage == null) {
			modelPackage = V3Package.eINSTANCE;
		}
	}

	/**
	 * Returns whether this factory is applicable for the type of the object.
	 * <!-- begin-user-doc -->
	 * This implementation returns <code>true</code> if the object is either the model's package or is an instance object of the model.
	 * <!-- end-user-doc -->
	 * @return whether this factory is applicable for the type of the object.
	 * @generated
	 */
	@Override
	public boolean isFactoryForType(Object object) {
		if (object == modelPackage) {
			return true;
		}
		if (object instanceof EObject) {
			return ((EObject)object).eClass().getEPackage() == modelPackage;
		}
		return false;
	}

	/**
	 * The switch the delegates to the <code>createXXX</code> methods.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 */
	protected V3Switch<Adapter> modelSwitch =
		new V3Switch<Adapter>() {
			@Override
			public Adapter caseAD(AD object) {
				return createADAdapter();
			}
			@Override
			public Adapter caseADXP(ADXP object) {
				return createADXPAdapter();
			}
			@Override
			public Adapter caseAdxpAdditionalLocator(AdxpAdditionalLocator object) {
				return createAdxpAdditionalLocatorAdapter();
			}
			@Override
			public Adapter caseAdxpBuildingNumberSuffix(AdxpBuildingNumberSuffix object) {
				return createAdxpBuildingNumberSuffixAdapter();
			}
			@Override
			public Adapter caseAdxpCareOf(AdxpCareOf object) {
				return createAdxpCareOfAdapter();
			}
			@Override
			public Adapter caseAdxpCensusTract(AdxpCensusTract object) {
				return createAdxpCensusTractAdapter();
			}
			@Override
			public Adapter caseAdxpCity(AdxpCity object) {
				return createAdxpCityAdapter();
			}
			@Override
			public Adapter caseAdxpCountry(AdxpCountry object) {
				return createAdxpCountryAdapter();
			}
			@Override
			public Adapter caseAdxpCounty(AdxpCounty object) {
				return createAdxpCountyAdapter();
			}
			@Override
			public Adapter caseAdxpDelimiter(AdxpDelimiter object) {
				return createAdxpDelimiterAdapter();
			}
			@Override
			public Adapter caseAdxpDeliveryAddressLine(AdxpDeliveryAddressLine object) {
				return createAdxpDeliveryAddressLineAdapter();
			}
			@Override
			public Adapter caseAdxpDeliveryInstallationArea(AdxpDeliveryInstallationArea object) {
				return createAdxpDeliveryInstallationAreaAdapter();
			}
			@Override
			public Adapter caseAdxpDeliveryInstallationQualifier(AdxpDeliveryInstallationQualifier object) {
				return createAdxpDeliveryInstallationQualifierAdapter();
			}
			@Override
			public Adapter caseAdxpDeliveryInstallationType(AdxpDeliveryInstallationType object) {
				return createAdxpDeliveryInstallationTypeAdapter();
			}
			@Override
			public Adapter caseAdxpDeliveryMode(AdxpDeliveryMode object) {
				return createAdxpDeliveryModeAdapter();
			}
			@Override
			public Adapter caseAdxpDeliveryModeIdentifier(AdxpDeliveryModeIdentifier object) {
				return createAdxpDeliveryModeIdentifierAdapter();
			}
			@Override
			public Adapter caseAdxpDirection(AdxpDirection object) {
				return createAdxpDirectionAdapter();
			}
			@Override
			public Adapter caseAdxpHouseNumber(AdxpHouseNumber object) {
				return createAdxpHouseNumberAdapter();
			}
			@Override
			public Adapter caseAdxpHouseNumberNumeric(AdxpHouseNumberNumeric object) {
				return createAdxpHouseNumberNumericAdapter();
			}
			@Override
			public Adapter caseAdxpPostalCode(AdxpPostalCode object) {
				return createAdxpPostalCodeAdapter();
			}
			@Override
			public Adapter caseAdxpPostBox(AdxpPostBox object) {
				return createAdxpPostBoxAdapter();
			}
			@Override
			public Adapter caseAdxpPrecinct(AdxpPrecinct object) {
				return createAdxpPrecinctAdapter();
			}
			@Override
			public Adapter caseAdxpState(AdxpState object) {
				return createAdxpStateAdapter();
			}
			@Override
			public Adapter caseAdxpStreetAddressLine(AdxpStreetAddressLine object) {
				return createAdxpStreetAddressLineAdapter();
			}
			@Override
			public Adapter caseAdxpStreetName(AdxpStreetName object) {
				return createAdxpStreetNameAdapter();
			}
			@Override
			public Adapter caseAdxpStreetNameBase(AdxpStreetNameBase object) {
				return createAdxpStreetNameBaseAdapter();
			}
			@Override
			public Adapter caseAdxpStreetNameType(AdxpStreetNameType object) {
				return createAdxpStreetNameTypeAdapter();
			}
			@Override
			public Adapter caseAdxpUnitID(AdxpUnitID object) {
				return createAdxpUnitIDAdapter();
			}
			@Override
			public Adapter caseAdxpUnitType(AdxpUnitType object) {
				return createAdxpUnitTypeAdapter();
			}
			@Override
			public Adapter caseANY(ANY object) {
				return createANYAdapter();
			}
			@Override
			public Adapter caseANYNonNull(ANYNonNull object) {
				return createANYNonNullAdapter();
			}
			@Override
			public Adapter caseBIN1(BIN1 object) {
				return createBIN1Adapter();
			}
			@Override
			public Adapter caseBL1(BL1 object) {
				return createBL1Adapter();
			}
			@Override
			public Adapter caseBN1(BN1 object) {
				return createBN1Adapter();
			}
			@Override
			public Adapter caseBXITCD(BXITCD object) {
				return createBXITCDAdapter();
			}
			@Override
			public Adapter caseBXITIVLPQ(BXITIVLPQ object) {
				return createBXITIVLPQAdapter();
			}
			@Override
			public Adapter caseCD(CD object) {
				return createCDAdapter();
			}
			@Override
			public Adapter caseCE(CE object) {
				return createCEAdapter();
			}
			@Override
			public Adapter caseCO(CO object) {
				return createCOAdapter();
			}
			@Override
			public Adapter caseCR(CR object) {
				return createCRAdapter();
			}
			@Override
			public Adapter caseCS1(CS1 object) {
				return createCS1Adapter();
			}
			@Override
			public Adapter caseCV(CV object) {
				return createCVAdapter();
			}
			@Override
			public Adapter caseDocumentRoot(DocumentRoot object) {
				return createDocumentRootAdapter();
			}
			@Override
			public Adapter caseED(ED object) {
				return createEDAdapter();
			}
			@Override
			public Adapter caseEIVLEvent(EIVLEvent object) {
				return createEIVLEventAdapter();
			}
			@Override
			public Adapter caseEIVLPPDTS(EIVLPPDTS object) {
				return createEIVLPPDTSAdapter();
			}
			@Override
			public Adapter caseEIVLTS(EIVLTS object) {
				return createEIVLTSAdapter();
			}
			@Override
			public Adapter caseEN(EN object) {
				return createENAdapter();
			}
			@Override
			public Adapter caseEnDelimiter(EnDelimiter object) {
				return createEnDelimiterAdapter();
			}
			@Override
			public Adapter caseEnFamily(EnFamily object) {
				return createEnFamilyAdapter();
			}
			@Override
			public Adapter caseEnGiven(EnGiven object) {
				return createEnGivenAdapter();
			}
			@Override
			public Adapter caseEnPrefix(EnPrefix object) {
				return createEnPrefixAdapter();
			}
			@Override
			public Adapter caseEnSuffix(EnSuffix object) {
				return createEnSuffixAdapter();
			}
			@Override
			public Adapter caseENXP(ENXP object) {
				return createENXPAdapter();
			}
			@Override
			public Adapter caseGLISTPQ(GLISTPQ object) {
				return createGLISTPQAdapter();
			}
			@Override
			public Adapter caseGLISTTS(GLISTTS object) {
				return createGLISTTSAdapter();
			}
			@Override
			public Adapter caseHXITCE(HXITCE object) {
				return createHXITCEAdapter();
			}
			@Override
			public Adapter caseHXITPQ(HXITPQ object) {
				return createHXITPQAdapter();
			}
			@Override
			public Adapter caseII(II object) {
				return createIIAdapter();
			}
			@Override
			public Adapter caseINT1(INT1 object) {
				return createINT1Adapter();
			}
			@Override
			public Adapter caseIVLINT(IVLINT object) {
				return createIVLINTAdapter();
			}
			@Override
			public Adapter caseIVLMO(IVLMO object) {
				return createIVLMOAdapter();
			}
			@Override
			public Adapter caseIVLPPDPQ(IVLPPDPQ object) {
				return createIVLPPDPQAdapter();
			}
			@Override
			public Adapter caseIVLPPDTS(IVLPPDTS object) {
				return createIVLPPDTSAdapter();
			}
			@Override
			public Adapter caseIVLPQ(IVLPQ object) {
				return createIVLPQAdapter();
			}
			@Override
			public Adapter caseIVLREAL(IVLREAL object) {
				return createIVLREALAdapter();
			}
			@Override
			public Adapter caseIVLTS(IVLTS object) {
				return createIVLTSAdapter();
			}
			@Override
			public Adapter caseIVXBINT(IVXBINT object) {
				return createIVXBINTAdapter();
			}
			@Override
			public Adapter caseIVXBMO(IVXBMO object) {
				return createIVXBMOAdapter();
			}
			@Override
			public Adapter caseIVXBPPDPQ(IVXBPPDPQ object) {
				return createIVXBPPDPQAdapter();
			}
			@Override
			public Adapter caseIVXBPPDTS(IVXBPPDTS object) {
				return createIVXBPPDTSAdapter();
			}
			@Override
			public Adapter caseIVXBPQ(IVXBPQ object) {
				return createIVXBPQAdapter();
			}
			@Override
			public Adapter caseIVXBREAL(IVXBREAL object) {
				return createIVXBREALAdapter();
			}
			@Override
			public Adapter caseIVXBTS(IVXBTS object) {
				return createIVXBTSAdapter();
			}
			@Override
			public Adapter caseMO(MO object) {
				return createMOAdapter();
			}
			@Override
			public Adapter caseON(ON object) {
				return createONAdapter();
			}
			@Override
			public Adapter casePIVLPPDTS(PIVLPPDTS object) {
				return createPIVLPPDTSAdapter();
			}
			@Override
			public Adapter casePIVLTS(PIVLTS object) {
				return createPIVLTSAdapter();
			}
			@Override
			public Adapter casePN(PN object) {
				return createPNAdapter();
			}
			@Override
			public Adapter casePOCDMT000040Act(POCDMT000040Act object) {
				return createPOCDMT000040ActAdapter();
			}
			@Override
			public Adapter casePOCDMT000040AssignedAuthor(POCDMT000040AssignedAuthor object) {
				return createPOCDMT000040AssignedAuthorAdapter();
			}
			@Override
			public Adapter casePOCDMT000040AssignedCustodian(POCDMT000040AssignedCustodian object) {
				return createPOCDMT000040AssignedCustodianAdapter();
			}
			@Override
			public Adapter casePOCDMT000040AssignedEntity(POCDMT000040AssignedEntity object) {
				return createPOCDMT000040AssignedEntityAdapter();
			}
			@Override
			public Adapter casePOCDMT000040AssociatedEntity(POCDMT000040AssociatedEntity object) {
				return createPOCDMT000040AssociatedEntityAdapter();
			}
			@Override
			public Adapter casePOCDMT000040Authenticator(POCDMT000040Authenticator object) {
				return createPOCDMT000040AuthenticatorAdapter();
			}
			@Override
			public Adapter casePOCDMT000040Author(POCDMT000040Author object) {
				return createPOCDMT000040AuthorAdapter();
			}
			@Override
			public Adapter casePOCDMT000040AuthoringDevice(POCDMT000040AuthoringDevice object) {
				return createPOCDMT000040AuthoringDeviceAdapter();
			}
			@Override
			public Adapter casePOCDMT000040Authorization(POCDMT000040Authorization object) {
				return createPOCDMT000040AuthorizationAdapter();
			}
			@Override
			public Adapter casePOCDMT000040Birthplace(POCDMT000040Birthplace object) {
				return createPOCDMT000040BirthplaceAdapter();
			}
			@Override
			public Adapter casePOCDMT000040ClinicalDocument(POCDMT000040ClinicalDocument object) {
				return createPOCDMT000040ClinicalDocumentAdapter();
			}
			@Override
			public Adapter casePOCDMT000040Component1(POCDMT000040Component1 object) {
				return createPOCDMT000040Component1Adapter();
			}
			@Override
			public Adapter casePOCDMT000040Component2(POCDMT000040Component2 object) {
				return createPOCDMT000040Component2Adapter();
			}
			@Override
			public Adapter casePOCDMT000040Component3(POCDMT000040Component3 object) {
				return createPOCDMT000040Component3Adapter();
			}
			@Override
			public Adapter casePOCDMT000040Component4(POCDMT000040Component4 object) {
				return createPOCDMT000040Component4Adapter();
			}
			@Override
			public Adapter casePOCDMT000040Component5(POCDMT000040Component5 object) {
				return createPOCDMT000040Component5Adapter();
			}
			@Override
			public Adapter casePOCDMT000040Consent(POCDMT000040Consent object) {
				return createPOCDMT000040ConsentAdapter();
			}
			@Override
			public Adapter casePOCDMT000040Consumable(POCDMT000040Consumable object) {
				return createPOCDMT000040ConsumableAdapter();
			}
			@Override
			public Adapter casePOCDMT000040Criterion(POCDMT000040Criterion object) {
				return createPOCDMT000040CriterionAdapter();
			}
			@Override
			public Adapter casePOCDMT000040Custodian(POCDMT000040Custodian object) {
				return createPOCDMT000040CustodianAdapter();
			}
			@Override
			public Adapter casePOCDMT000040CustodianOrganization(POCDMT000040CustodianOrganization object) {
				return createPOCDMT000040CustodianOrganizationAdapter();
			}
			@Override
			public Adapter casePOCDMT000040DataEnterer(POCDMT000040DataEnterer object) {
				return createPOCDMT000040DataEntererAdapter();
			}
			@Override
			public Adapter casePOCDMT000040Device(POCDMT000040Device object) {
				return createPOCDMT000040DeviceAdapter();
			}
			@Override
			public Adapter casePOCDMT000040DocumentationOf(POCDMT000040DocumentationOf object) {
				return createPOCDMT000040DocumentationOfAdapter();
			}
			@Override
			public Adapter casePOCDMT000040EncompassingEncounter(POCDMT000040EncompassingEncounter object) {
				return createPOCDMT000040EncompassingEncounterAdapter();
			}
			@Override
			public Adapter casePOCDMT000040Encounter(POCDMT000040Encounter object) {
				return createPOCDMT000040EncounterAdapter();
			}
			@Override
			public Adapter casePOCDMT000040EncounterParticipant(POCDMT000040EncounterParticipant object) {
				return createPOCDMT000040EncounterParticipantAdapter();
			}
			@Override
			public Adapter casePOCDMT000040Entity(POCDMT000040Entity object) {
				return createPOCDMT000040EntityAdapter();
			}
			@Override
			public Adapter casePOCDMT000040Entry(POCDMT000040Entry object) {
				return createPOCDMT000040EntryAdapter();
			}
			@Override
			public Adapter casePOCDMT000040EntryRelationship(POCDMT000040EntryRelationship object) {
				return createPOCDMT000040EntryRelationshipAdapter();
			}
			@Override
			public Adapter casePOCDMT000040ExternalAct(POCDMT000040ExternalAct object) {
				return createPOCDMT000040ExternalActAdapter();
			}
			@Override
			public Adapter casePOCDMT000040ExternalDocument(POCDMT000040ExternalDocument object) {
				return createPOCDMT000040ExternalDocumentAdapter();
			}
			@Override
			public Adapter casePOCDMT000040ExternalObservation(POCDMT000040ExternalObservation object) {
				return createPOCDMT000040ExternalObservationAdapter();
			}
			@Override
			public Adapter casePOCDMT000040ExternalProcedure(POCDMT000040ExternalProcedure object) {
				return createPOCDMT000040ExternalProcedureAdapter();
			}
			@Override
			public Adapter casePOCDMT000040Guardian(POCDMT000040Guardian object) {
				return createPOCDMT000040GuardianAdapter();
			}
			@Override
			public Adapter casePOCDMT000040HealthCareFacility(POCDMT000040HealthCareFacility object) {
				return createPOCDMT000040HealthCareFacilityAdapter();
			}
			@Override
			public Adapter casePOCDMT000040Informant12(POCDMT000040Informant12 object) {
				return createPOCDMT000040Informant12Adapter();
			}
			@Override
			public Adapter casePOCDMT000040InformationRecipient(POCDMT000040InformationRecipient object) {
				return createPOCDMT000040InformationRecipientAdapter();
			}
			@Override
			public Adapter casePOCDMT000040InfrastructureRootTypeId(POCDMT000040InfrastructureRootTypeId object) {
				return createPOCDMT000040InfrastructureRootTypeIdAdapter();
			}
			@Override
			public Adapter casePOCDMT000040InFulfillmentOf(POCDMT000040InFulfillmentOf object) {
				return createPOCDMT000040InFulfillmentOfAdapter();
			}
			@Override
			public Adapter casePOCDMT000040IntendedRecipient(POCDMT000040IntendedRecipient object) {
				return createPOCDMT000040IntendedRecipientAdapter();
			}
			@Override
			public Adapter casePOCDMT000040LabeledDrug(POCDMT000040LabeledDrug object) {
				return createPOCDMT000040LabeledDrugAdapter();
			}
			@Override
			public Adapter casePOCDMT000040LanguageCommunication(POCDMT000040LanguageCommunication object) {
				return createPOCDMT000040LanguageCommunicationAdapter();
			}
			@Override
			public Adapter casePOCDMT000040LegalAuthenticator(POCDMT000040LegalAuthenticator object) {
				return createPOCDMT000040LegalAuthenticatorAdapter();
			}
			@Override
			public Adapter casePOCDMT000040Location(POCDMT000040Location object) {
				return createPOCDMT000040LocationAdapter();
			}
			@Override
			public Adapter casePOCDMT000040MaintainedEntity(POCDMT000040MaintainedEntity object) {
				return createPOCDMT000040MaintainedEntityAdapter();
			}
			@Override
			public Adapter casePOCDMT000040ManufacturedProduct(POCDMT000040ManufacturedProduct object) {
				return createPOCDMT000040ManufacturedProductAdapter();
			}
			@Override
			public Adapter casePOCDMT000040Material(POCDMT000040Material object) {
				return createPOCDMT000040MaterialAdapter();
			}
			@Override
			public Adapter casePOCDMT000040NonXMLBody(POCDMT000040NonXMLBody object) {
				return createPOCDMT000040NonXMLBodyAdapter();
			}
			@Override
			public Adapter casePOCDMT000040Observation(POCDMT000040Observation object) {
				return createPOCDMT000040ObservationAdapter();
			}
			@Override
			public Adapter casePOCDMT000040ObservationMedia(POCDMT000040ObservationMedia object) {
				return createPOCDMT000040ObservationMediaAdapter();
			}
			@Override
			public Adapter casePOCDMT000040ObservationRange(POCDMT000040ObservationRange object) {
				return createPOCDMT000040ObservationRangeAdapter();
			}
			@Override
			public Adapter casePOCDMT000040Order(POCDMT000040Order object) {
				return createPOCDMT000040OrderAdapter();
			}
			@Override
			public Adapter casePOCDMT000040Organization(POCDMT000040Organization object) {
				return createPOCDMT000040OrganizationAdapter();
			}
			@Override
			public Adapter casePOCDMT000040OrganizationPartOf(POCDMT000040OrganizationPartOf object) {
				return createPOCDMT000040OrganizationPartOfAdapter();
			}
			@Override
			public Adapter casePOCDMT000040Organizer(POCDMT000040Organizer object) {
				return createPOCDMT000040OrganizerAdapter();
			}
			@Override
			public Adapter casePOCDMT000040ParentDocument(POCDMT000040ParentDocument object) {
				return createPOCDMT000040ParentDocumentAdapter();
			}
			@Override
			public Adapter casePOCDMT000040Participant1(POCDMT000040Participant1 object) {
				return createPOCDMT000040Participant1Adapter();
			}
			@Override
			public Adapter casePOCDMT000040Participant2(POCDMT000040Participant2 object) {
				return createPOCDMT000040Participant2Adapter();
			}
			@Override
			public Adapter casePOCDMT000040ParticipantRole(POCDMT000040ParticipantRole object) {
				return createPOCDMT000040ParticipantRoleAdapter();
			}
			@Override
			public Adapter casePOCDMT000040Patient(POCDMT000040Patient object) {
				return createPOCDMT000040PatientAdapter();
			}
			@Override
			public Adapter casePOCDMT000040PatientRole(POCDMT000040PatientRole object) {
				return createPOCDMT000040PatientRoleAdapter();
			}
			@Override
			public Adapter casePOCDMT000040Performer1(POCDMT000040Performer1 object) {
				return createPOCDMT000040Performer1Adapter();
			}
			@Override
			public Adapter casePOCDMT000040Performer2(POCDMT000040Performer2 object) {
				return createPOCDMT000040Performer2Adapter();
			}
			@Override
			public Adapter casePOCDMT000040Person(POCDMT000040Person object) {
				return createPOCDMT000040PersonAdapter();
			}
			@Override
			public Adapter casePOCDMT000040Place(POCDMT000040Place object) {
				return createPOCDMT000040PlaceAdapter();
			}
			@Override
			public Adapter casePOCDMT000040PlayingEntity(POCDMT000040PlayingEntity object) {
				return createPOCDMT000040PlayingEntityAdapter();
			}
			@Override
			public Adapter casePOCDMT000040Precondition(POCDMT000040Precondition object) {
				return createPOCDMT000040PreconditionAdapter();
			}
			@Override
			public Adapter casePOCDMT000040Procedure(POCDMT000040Procedure object) {
				return createPOCDMT000040ProcedureAdapter();
			}
			@Override
			public Adapter casePOCDMT000040Product(POCDMT000040Product object) {
				return createPOCDMT000040ProductAdapter();
			}
			@Override
			public Adapter casePOCDMT000040RecordTarget(POCDMT000040RecordTarget object) {
				return createPOCDMT000040RecordTargetAdapter();
			}
			@Override
			public Adapter casePOCDMT000040Reference(POCDMT000040Reference object) {
				return createPOCDMT000040ReferenceAdapter();
			}
			@Override
			public Adapter casePOCDMT000040ReferenceRange(POCDMT000040ReferenceRange object) {
				return createPOCDMT000040ReferenceRangeAdapter();
			}
			@Override
			public Adapter casePOCDMT000040RegionOfInterest(POCDMT000040RegionOfInterest object) {
				return createPOCDMT000040RegionOfInterestAdapter();
			}
			@Override
			public Adapter casePOCDMT000040RegionOfInterestValue(POCDMT000040RegionOfInterestValue object) {
				return createPOCDMT000040RegionOfInterestValueAdapter();
			}
			@Override
			public Adapter casePOCDMT000040RelatedDocument(POCDMT000040RelatedDocument object) {
				return createPOCDMT000040RelatedDocumentAdapter();
			}
			@Override
			public Adapter casePOCDMT000040RelatedEntity(POCDMT000040RelatedEntity object) {
				return createPOCDMT000040RelatedEntityAdapter();
			}
			@Override
			public Adapter casePOCDMT000040RelatedSubject(POCDMT000040RelatedSubject object) {
				return createPOCDMT000040RelatedSubjectAdapter();
			}
			@Override
			public Adapter casePOCDMT000040ResponsibleParty(POCDMT000040ResponsibleParty object) {
				return createPOCDMT000040ResponsiblePartyAdapter();
			}
			@Override
			public Adapter casePOCDMT000040Section(POCDMT000040Section object) {
				return createPOCDMT000040SectionAdapter();
			}
			@Override
			public Adapter casePOCDMT000040ServiceEvent(POCDMT000040ServiceEvent object) {
				return createPOCDMT000040ServiceEventAdapter();
			}
			@Override
			public Adapter casePOCDMT000040Specimen(POCDMT000040Specimen object) {
				return createPOCDMT000040SpecimenAdapter();
			}
			@Override
			public Adapter casePOCDMT000040SpecimenRole(POCDMT000040SpecimenRole object) {
				return createPOCDMT000040SpecimenRoleAdapter();
			}
			@Override
			public Adapter casePOCDMT000040StructuredBody(POCDMT000040StructuredBody object) {
				return createPOCDMT000040StructuredBodyAdapter();
			}
			@Override
			public Adapter casePOCDMT000040Subject(POCDMT000040Subject object) {
				return createPOCDMT000040SubjectAdapter();
			}
			@Override
			public Adapter casePOCDMT000040SubjectPerson(POCDMT000040SubjectPerson object) {
				return createPOCDMT000040SubjectPersonAdapter();
			}
			@Override
			public Adapter casePOCDMT000040SubstanceAdministration(POCDMT000040SubstanceAdministration object) {
				return createPOCDMT000040SubstanceAdministrationAdapter();
			}
			@Override
			public Adapter casePOCDMT000040Supply(POCDMT000040Supply object) {
				return createPOCDMT000040SupplyAdapter();
			}
			@Override
			public Adapter casePPDPQ(PPDPQ object) {
				return createPPDPQAdapter();
			}
			@Override
			public Adapter casePPDTS(PPDTS object) {
				return createPPDTSAdapter();
			}
			@Override
			public Adapter casePQ(PQ object) {
				return createPQAdapter();
			}
			@Override
			public Adapter casePQR(PQR object) {
				return createPQRAdapter();
			}
			@Override
			public Adapter caseQTY(QTY object) {
				return createQTYAdapter();
			}
			@Override
			public Adapter caseREAL1(REAL1 object) {
				return createREAL1Adapter();
			}
			@Override
			public Adapter caseRTO(RTO object) {
				return createRTOAdapter();
			}
			@Override
			public Adapter caseRTOMOPQ(RTOMOPQ object) {
				return createRTOMOPQAdapter();
			}
			@Override
			public Adapter caseRTOPQPQ(RTOPQPQ object) {
				return createRTOPQPQAdapter();
			}
			@Override
			public Adapter caseRTOQTYQTY(RTOQTYQTY object) {
				return createRTOQTYQTYAdapter();
			}
			@Override
			public Adapter caseSC(SC object) {
				return createSCAdapter();
			}
			@Override
			public Adapter caseSLISTPQ(SLISTPQ object) {
				return createSLISTPQAdapter();
			}
			@Override
			public Adapter caseSLISTTS(SLISTTS object) {
				return createSLISTTSAdapter();
			}
			@Override
			public Adapter caseST1(ST1 object) {
				return createST1Adapter();
			}
			@Override
			public Adapter caseStrucDocBr(StrucDocBr object) {
				return createStrucDocBrAdapter();
			}
			@Override
			public Adapter caseStrucDocCaption(StrucDocCaption object) {
				return createStrucDocCaptionAdapter();
			}
			@Override
			public Adapter caseStrucDocCol(StrucDocCol object) {
				return createStrucDocColAdapter();
			}
			@Override
			public Adapter caseStrucDocColgroup(StrucDocColgroup object) {
				return createStrucDocColgroupAdapter();
			}
			@Override
			public Adapter caseStrucDocContent(StrucDocContent object) {
				return createStrucDocContentAdapter();
			}
			@Override
			public Adapter caseStrucDocFootnote(StrucDocFootnote object) {
				return createStrucDocFootnoteAdapter();
			}
			@Override
			public Adapter caseStrucDocFootnoteRef(StrucDocFootnoteRef object) {
				return createStrucDocFootnoteRefAdapter();
			}
			@Override
			public Adapter caseStrucDocItem(StrucDocItem object) {
				return createStrucDocItemAdapter();
			}
			@Override
			public Adapter caseStrucDocLinkHtml(StrucDocLinkHtml object) {
				return createStrucDocLinkHtmlAdapter();
			}
			@Override
			public Adapter caseStrucDocList(StrucDocList object) {
				return createStrucDocListAdapter();
			}
			@Override
			public Adapter caseStrucDocParagraph(StrucDocParagraph object) {
				return createStrucDocParagraphAdapter();
			}
			@Override
			public Adapter caseStrucDocRenderMultiMedia(StrucDocRenderMultiMedia object) {
				return createStrucDocRenderMultiMediaAdapter();
			}
			@Override
			public Adapter caseStrucDocSub(StrucDocSub object) {
				return createStrucDocSubAdapter();
			}
			@Override
			public Adapter caseStrucDocSup(StrucDocSup object) {
				return createStrucDocSupAdapter();
			}
			@Override
			public Adapter caseStrucDocTable(StrucDocTable object) {
				return createStrucDocTableAdapter();
			}
			@Override
			public Adapter caseStrucDocTbody(StrucDocTbody object) {
				return createStrucDocTbodyAdapter();
			}
			@Override
			public Adapter caseStrucDocTd(StrucDocTd object) {
				return createStrucDocTdAdapter();
			}
			@Override
			public Adapter caseStrucDocText(StrucDocText object) {
				return createStrucDocTextAdapter();
			}
			@Override
			public Adapter caseStrucDocTfoot(StrucDocTfoot object) {
				return createStrucDocTfootAdapter();
			}
			@Override
			public Adapter caseStrucDocTh(StrucDocTh object) {
				return createStrucDocThAdapter();
			}
			@Override
			public Adapter caseStrucDocThead(StrucDocThead object) {
				return createStrucDocTheadAdapter();
			}
			@Override
			public Adapter caseStrucDocTitle(StrucDocTitle object) {
				return createStrucDocTitleAdapter();
			}
			@Override
			public Adapter caseStrucDocTitleContent(StrucDocTitleContent object) {
				return createStrucDocTitleContentAdapter();
			}
			@Override
			public Adapter caseStrucDocTitleFootnote(StrucDocTitleFootnote object) {
				return createStrucDocTitleFootnoteAdapter();
			}
			@Override
			public Adapter caseStrucDocTr(StrucDocTr object) {
				return createStrucDocTrAdapter();
			}
			@Override
			public Adapter caseSXCMCD(SXCMCD object) {
				return createSXCMCDAdapter();
			}
			@Override
			public Adapter caseSXCMINT(SXCMINT object) {
				return createSXCMINTAdapter();
			}
			@Override
			public Adapter caseSXCMMO(SXCMMO object) {
				return createSXCMMOAdapter();
			}
			@Override
			public Adapter caseSXCMPPDPQ(SXCMPPDPQ object) {
				return createSXCMPPDPQAdapter();
			}
			@Override
			public Adapter caseSXCMPPDTS(SXCMPPDTS object) {
				return createSXCMPPDTSAdapter();
			}
			@Override
			public Adapter caseSXCMPQ(SXCMPQ object) {
				return createSXCMPQAdapter();
			}
			@Override
			public Adapter caseSXCMREAL(SXCMREAL object) {
				return createSXCMREALAdapter();
			}
			@Override
			public Adapter caseSXCMTS(SXCMTS object) {
				return createSXCMTSAdapter();
			}
			@Override
			public Adapter caseSXPRTS(SXPRTS object) {
				return createSXPRTSAdapter();
			}
			@Override
			public Adapter caseTEL(TEL object) {
				return createTELAdapter();
			}
			@Override
			public Adapter caseThumbnail(Thumbnail object) {
				return createThumbnailAdapter();
			}
			@Override
			public Adapter caseTN(TN object) {
				return createTNAdapter();
			}
			@Override
			public Adapter caseTS1(TS1 object) {
				return createTS1Adapter();
			}
			@Override
			public Adapter caseURL1(URL1 object) {
				return createURL1Adapter();
			}
			@Override
			public Adapter caseUVPTS(UVPTS object) {
				return createUVPTSAdapter();
			}
			@Override
			public Adapter defaultCase(EObject object) {
				return createEObjectAdapter();
			}
		};

	/**
	 * Creates an adapter for the <code>target</code>.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @param target the object to adapt.
	 * @return the adapter for the <code>target</code>.
	 * @generated
	 */
	@Override
	public Adapter createAdapter(Notifier target) {
		return modelSwitch.doSwitch((EObject)target);
	}


	/**
	 * Creates a new adapter for an object of class '{@link org.hl7.v3.AD <em>AD</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.hl7.v3.AD
	 * @generated
	 */
	public Adapter createADAdapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.hl7.v3.ADXP <em>ADXP</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.hl7.v3.ADXP
	 * @generated
	 */
	public Adapter createADXPAdapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.hl7.v3.AdxpAdditionalLocator <em>Adxp Additional Locator</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.hl7.v3.AdxpAdditionalLocator
	 * @generated
	 */
	public Adapter createAdxpAdditionalLocatorAdapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.hl7.v3.AdxpBuildingNumberSuffix <em>Adxp Building Number Suffix</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.hl7.v3.AdxpBuildingNumberSuffix
	 * @generated
	 */
	public Adapter createAdxpBuildingNumberSuffixAdapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.hl7.v3.AdxpCareOf <em>Adxp Care Of</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.hl7.v3.AdxpCareOf
	 * @generated
	 */
	public Adapter createAdxpCareOfAdapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.hl7.v3.AdxpCensusTract <em>Adxp Census Tract</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.hl7.v3.AdxpCensusTract
	 * @generated
	 */
	public Adapter createAdxpCensusTractAdapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.hl7.v3.AdxpCity <em>Adxp City</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.hl7.v3.AdxpCity
	 * @generated
	 */
	public Adapter createAdxpCityAdapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.hl7.v3.AdxpCountry <em>Adxp Country</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.hl7.v3.AdxpCountry
	 * @generated
	 */
	public Adapter createAdxpCountryAdapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.hl7.v3.AdxpCounty <em>Adxp County</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.hl7.v3.AdxpCounty
	 * @generated
	 */
	public Adapter createAdxpCountyAdapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.hl7.v3.AdxpDelimiter <em>Adxp Delimiter</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.hl7.v3.AdxpDelimiter
	 * @generated
	 */
	public Adapter createAdxpDelimiterAdapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.hl7.v3.AdxpDeliveryAddressLine <em>Adxp Delivery Address Line</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.hl7.v3.AdxpDeliveryAddressLine
	 * @generated
	 */
	public Adapter createAdxpDeliveryAddressLineAdapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.hl7.v3.AdxpDeliveryInstallationArea <em>Adxp Delivery Installation Area</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.hl7.v3.AdxpDeliveryInstallationArea
	 * @generated
	 */
	public Adapter createAdxpDeliveryInstallationAreaAdapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.hl7.v3.AdxpDeliveryInstallationQualifier <em>Adxp Delivery Installation Qualifier</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.hl7.v3.AdxpDeliveryInstallationQualifier
	 * @generated
	 */
	public Adapter createAdxpDeliveryInstallationQualifierAdapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.hl7.v3.AdxpDeliveryInstallationType <em>Adxp Delivery Installation Type</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.hl7.v3.AdxpDeliveryInstallationType
	 * @generated
	 */
	public Adapter createAdxpDeliveryInstallationTypeAdapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.hl7.v3.AdxpDeliveryMode <em>Adxp Delivery Mode</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.hl7.v3.AdxpDeliveryMode
	 * @generated
	 */
	public Adapter createAdxpDeliveryModeAdapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.hl7.v3.AdxpDeliveryModeIdentifier <em>Adxp Delivery Mode Identifier</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.hl7.v3.AdxpDeliveryModeIdentifier
	 * @generated
	 */
	public Adapter createAdxpDeliveryModeIdentifierAdapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.hl7.v3.AdxpDirection <em>Adxp Direction</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.hl7.v3.AdxpDirection
	 * @generated
	 */
	public Adapter createAdxpDirectionAdapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.hl7.v3.AdxpHouseNumber <em>Adxp House Number</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.hl7.v3.AdxpHouseNumber
	 * @generated
	 */
	public Adapter createAdxpHouseNumberAdapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.hl7.v3.AdxpHouseNumberNumeric <em>Adxp House Number Numeric</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.hl7.v3.AdxpHouseNumberNumeric
	 * @generated
	 */
	public Adapter createAdxpHouseNumberNumericAdapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.hl7.v3.AdxpPostalCode <em>Adxp Postal Code</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.hl7.v3.AdxpPostalCode
	 * @generated
	 */
	public Adapter createAdxpPostalCodeAdapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.hl7.v3.AdxpPostBox <em>Adxp Post Box</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.hl7.v3.AdxpPostBox
	 * @generated
	 */
	public Adapter createAdxpPostBoxAdapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.hl7.v3.AdxpPrecinct <em>Adxp Precinct</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.hl7.v3.AdxpPrecinct
	 * @generated
	 */
	public Adapter createAdxpPrecinctAdapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.hl7.v3.AdxpState <em>Adxp State</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.hl7.v3.AdxpState
	 * @generated
	 */
	public Adapter createAdxpStateAdapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.hl7.v3.AdxpStreetAddressLine <em>Adxp Street Address Line</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.hl7.v3.AdxpStreetAddressLine
	 * @generated
	 */
	public Adapter createAdxpStreetAddressLineAdapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.hl7.v3.AdxpStreetName <em>Adxp Street Name</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.hl7.v3.AdxpStreetName
	 * @generated
	 */
	public Adapter createAdxpStreetNameAdapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.hl7.v3.AdxpStreetNameBase <em>Adxp Street Name Base</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.hl7.v3.AdxpStreetNameBase
	 * @generated
	 */
	public Adapter createAdxpStreetNameBaseAdapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.hl7.v3.AdxpStreetNameType <em>Adxp Street Name Type</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.hl7.v3.AdxpStreetNameType
	 * @generated
	 */
	public Adapter createAdxpStreetNameTypeAdapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.hl7.v3.AdxpUnitID <em>Adxp Unit ID</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.hl7.v3.AdxpUnitID
	 * @generated
	 */
	public Adapter createAdxpUnitIDAdapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.hl7.v3.AdxpUnitType <em>Adxp Unit Type</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.hl7.v3.AdxpUnitType
	 * @generated
	 */
	public Adapter createAdxpUnitTypeAdapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.hl7.v3.ANY <em>ANY</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.hl7.v3.ANY
	 * @generated
	 */
	public Adapter createANYAdapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.hl7.v3.ANYNonNull <em>ANY Non Null</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.hl7.v3.ANYNonNull
	 * @generated
	 */
	public Adapter createANYNonNullAdapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.hl7.v3.BIN1 <em>BIN1</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.hl7.v3.BIN1
	 * @generated
	 */
	public Adapter createBIN1Adapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.hl7.v3.BL1 <em>BL1</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.hl7.v3.BL1
	 * @generated
	 */
	public Adapter createBL1Adapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.hl7.v3.BN1 <em>BN1</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.hl7.v3.BN1
	 * @generated
	 */
	public Adapter createBN1Adapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.hl7.v3.BXITCD <em>BXITCD</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.hl7.v3.BXITCD
	 * @generated
	 */
	public Adapter createBXITCDAdapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.hl7.v3.BXITIVLPQ <em>BXITIVLPQ</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.hl7.v3.BXITIVLPQ
	 * @generated
	 */
	public Adapter createBXITIVLPQAdapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.hl7.v3.CD <em>CD</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.hl7.v3.CD
	 * @generated
	 */
	public Adapter createCDAdapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.hl7.v3.CE <em>CE</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.hl7.v3.CE
	 * @generated
	 */
	public Adapter createCEAdapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.hl7.v3.CO <em>CO</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.hl7.v3.CO
	 * @generated
	 */
	public Adapter createCOAdapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.hl7.v3.CR <em>CR</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.hl7.v3.CR
	 * @generated
	 */
	public Adapter createCRAdapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.hl7.v3.CS1 <em>CS1</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.hl7.v3.CS1
	 * @generated
	 */
	public Adapter createCS1Adapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.hl7.v3.CV <em>CV</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.hl7.v3.CV
	 * @generated
	 */
	public Adapter createCVAdapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.hl7.v3.DocumentRoot <em>Document Root</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.hl7.v3.DocumentRoot
	 * @generated
	 */
	public Adapter createDocumentRootAdapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.hl7.v3.ED <em>ED</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.hl7.v3.ED
	 * @generated
	 */
	public Adapter createEDAdapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.hl7.v3.EIVLEvent <em>EIVL Event</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.hl7.v3.EIVLEvent
	 * @generated
	 */
	public Adapter createEIVLEventAdapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.hl7.v3.EIVLPPDTS <em>EIVLPPDTS</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.hl7.v3.EIVLPPDTS
	 * @generated
	 */
	public Adapter createEIVLPPDTSAdapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.hl7.v3.EIVLTS <em>EIVLTS</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.hl7.v3.EIVLTS
	 * @generated
	 */
	public Adapter createEIVLTSAdapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.hl7.v3.EN <em>EN</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.hl7.v3.EN
	 * @generated
	 */
	public Adapter createENAdapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.hl7.v3.EnDelimiter <em>En Delimiter</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.hl7.v3.EnDelimiter
	 * @generated
	 */
	public Adapter createEnDelimiterAdapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.hl7.v3.EnFamily <em>En Family</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.hl7.v3.EnFamily
	 * @generated
	 */
	public Adapter createEnFamilyAdapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.hl7.v3.EnGiven <em>En Given</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.hl7.v3.EnGiven
	 * @generated
	 */
	public Adapter createEnGivenAdapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.hl7.v3.EnPrefix <em>En Prefix</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.hl7.v3.EnPrefix
	 * @generated
	 */
	public Adapter createEnPrefixAdapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.hl7.v3.EnSuffix <em>En Suffix</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.hl7.v3.EnSuffix
	 * @generated
	 */
	public Adapter createEnSuffixAdapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.hl7.v3.ENXP <em>ENXP</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.hl7.v3.ENXP
	 * @generated
	 */
	public Adapter createENXPAdapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.hl7.v3.GLISTPQ <em>GLISTPQ</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.hl7.v3.GLISTPQ
	 * @generated
	 */
	public Adapter createGLISTPQAdapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.hl7.v3.GLISTTS <em>GLISTTS</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.hl7.v3.GLISTTS
	 * @generated
	 */
	public Adapter createGLISTTSAdapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.hl7.v3.HXITCE <em>HXITCE</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.hl7.v3.HXITCE
	 * @generated
	 */
	public Adapter createHXITCEAdapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.hl7.v3.HXITPQ <em>HXITPQ</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.hl7.v3.HXITPQ
	 * @generated
	 */
	public Adapter createHXITPQAdapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.hl7.v3.II <em>II</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.hl7.v3.II
	 * @generated
	 */
	public Adapter createIIAdapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.hl7.v3.INT1 <em>INT1</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.hl7.v3.INT1
	 * @generated
	 */
	public Adapter createINT1Adapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.hl7.v3.IVLINT <em>IVLINT</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.hl7.v3.IVLINT
	 * @generated
	 */
	public Adapter createIVLINTAdapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.hl7.v3.IVLMO <em>IVLMO</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.hl7.v3.IVLMO
	 * @generated
	 */
	public Adapter createIVLMOAdapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.hl7.v3.IVLPPDPQ <em>IVLPPDPQ</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.hl7.v3.IVLPPDPQ
	 * @generated
	 */
	public Adapter createIVLPPDPQAdapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.hl7.v3.IVLPPDTS <em>IVLPPDTS</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.hl7.v3.IVLPPDTS
	 * @generated
	 */
	public Adapter createIVLPPDTSAdapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.hl7.v3.IVLPQ <em>IVLPQ</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.hl7.v3.IVLPQ
	 * @generated
	 */
	public Adapter createIVLPQAdapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.hl7.v3.IVLREAL <em>IVLREAL</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.hl7.v3.IVLREAL
	 * @generated
	 */
	public Adapter createIVLREALAdapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.hl7.v3.IVLTS <em>IVLTS</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.hl7.v3.IVLTS
	 * @generated
	 */
	public Adapter createIVLTSAdapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.hl7.v3.IVXBINT <em>IVXBINT</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.hl7.v3.IVXBINT
	 * @generated
	 */
	public Adapter createIVXBINTAdapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.hl7.v3.IVXBMO <em>IVXBMO</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.hl7.v3.IVXBMO
	 * @generated
	 */
	public Adapter createIVXBMOAdapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.hl7.v3.IVXBPPDPQ <em>IVXBPPDPQ</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.hl7.v3.IVXBPPDPQ
	 * @generated
	 */
	public Adapter createIVXBPPDPQAdapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.hl7.v3.IVXBPPDTS <em>IVXBPPDTS</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.hl7.v3.IVXBPPDTS
	 * @generated
	 */
	public Adapter createIVXBPPDTSAdapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.hl7.v3.IVXBPQ <em>IVXBPQ</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.hl7.v3.IVXBPQ
	 * @generated
	 */
	public Adapter createIVXBPQAdapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.hl7.v3.IVXBREAL <em>IVXBREAL</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.hl7.v3.IVXBREAL
	 * @generated
	 */
	public Adapter createIVXBREALAdapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.hl7.v3.IVXBTS <em>IVXBTS</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.hl7.v3.IVXBTS
	 * @generated
	 */
	public Adapter createIVXBTSAdapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.hl7.v3.MO <em>MO</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.hl7.v3.MO
	 * @generated
	 */
	public Adapter createMOAdapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.hl7.v3.ON <em>ON</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.hl7.v3.ON
	 * @generated
	 */
	public Adapter createONAdapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.hl7.v3.PIVLPPDTS <em>PIVLPPDTS</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.hl7.v3.PIVLPPDTS
	 * @generated
	 */
	public Adapter createPIVLPPDTSAdapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.hl7.v3.PIVLTS <em>PIVLTS</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.hl7.v3.PIVLTS
	 * @generated
	 */
	public Adapter createPIVLTSAdapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.hl7.v3.PN <em>PN</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.hl7.v3.PN
	 * @generated
	 */
	public Adapter createPNAdapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.hl7.v3.POCDMT000040Act <em>POCDMT000040 Act</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.hl7.v3.POCDMT000040Act
	 * @generated
	 */
	public Adapter createPOCDMT000040ActAdapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.hl7.v3.POCDMT000040AssignedAuthor <em>POCDMT000040 Assigned Author</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.hl7.v3.POCDMT000040AssignedAuthor
	 * @generated
	 */
	public Adapter createPOCDMT000040AssignedAuthorAdapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.hl7.v3.POCDMT000040AssignedCustodian <em>POCDMT000040 Assigned Custodian</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.hl7.v3.POCDMT000040AssignedCustodian
	 * @generated
	 */
	public Adapter createPOCDMT000040AssignedCustodianAdapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.hl7.v3.POCDMT000040AssignedEntity <em>POCDMT000040 Assigned Entity</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.hl7.v3.POCDMT000040AssignedEntity
	 * @generated
	 */
	public Adapter createPOCDMT000040AssignedEntityAdapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.hl7.v3.POCDMT000040AssociatedEntity <em>POCDMT000040 Associated Entity</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.hl7.v3.POCDMT000040AssociatedEntity
	 * @generated
	 */
	public Adapter createPOCDMT000040AssociatedEntityAdapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.hl7.v3.POCDMT000040Authenticator <em>POCDMT000040 Authenticator</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.hl7.v3.POCDMT000040Authenticator
	 * @generated
	 */
	public Adapter createPOCDMT000040AuthenticatorAdapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.hl7.v3.POCDMT000040Author <em>POCDMT000040 Author</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.hl7.v3.POCDMT000040Author
	 * @generated
	 */
	public Adapter createPOCDMT000040AuthorAdapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.hl7.v3.POCDMT000040AuthoringDevice <em>POCDMT000040 Authoring Device</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.hl7.v3.POCDMT000040AuthoringDevice
	 * @generated
	 */
	public Adapter createPOCDMT000040AuthoringDeviceAdapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.hl7.v3.POCDMT000040Authorization <em>POCDMT000040 Authorization</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.hl7.v3.POCDMT000040Authorization
	 * @generated
	 */
	public Adapter createPOCDMT000040AuthorizationAdapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.hl7.v3.POCDMT000040Birthplace <em>POCDMT000040 Birthplace</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.hl7.v3.POCDMT000040Birthplace
	 * @generated
	 */
	public Adapter createPOCDMT000040BirthplaceAdapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.hl7.v3.POCDMT000040ClinicalDocument <em>POCDMT000040 Clinical Document</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.hl7.v3.POCDMT000040ClinicalDocument
	 * @generated
	 */
	public Adapter createPOCDMT000040ClinicalDocumentAdapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.hl7.v3.POCDMT000040Component1 <em>POCDMT000040 Component1</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.hl7.v3.POCDMT000040Component1
	 * @generated
	 */
	public Adapter createPOCDMT000040Component1Adapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.hl7.v3.POCDMT000040Component2 <em>POCDMT000040 Component2</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.hl7.v3.POCDMT000040Component2
	 * @generated
	 */
	public Adapter createPOCDMT000040Component2Adapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.hl7.v3.POCDMT000040Component3 <em>POCDMT000040 Component3</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.hl7.v3.POCDMT000040Component3
	 * @generated
	 */
	public Adapter createPOCDMT000040Component3Adapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.hl7.v3.POCDMT000040Component4 <em>POCDMT000040 Component4</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.hl7.v3.POCDMT000040Component4
	 * @generated
	 */
	public Adapter createPOCDMT000040Component4Adapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.hl7.v3.POCDMT000040Component5 <em>POCDMT000040 Component5</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.hl7.v3.POCDMT000040Component5
	 * @generated
	 */
	public Adapter createPOCDMT000040Component5Adapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.hl7.v3.POCDMT000040Consent <em>POCDMT000040 Consent</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.hl7.v3.POCDMT000040Consent
	 * @generated
	 */
	public Adapter createPOCDMT000040ConsentAdapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.hl7.v3.POCDMT000040Consumable <em>POCDMT000040 Consumable</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.hl7.v3.POCDMT000040Consumable
	 * @generated
	 */
	public Adapter createPOCDMT000040ConsumableAdapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.hl7.v3.POCDMT000040Criterion <em>POCDMT000040 Criterion</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.hl7.v3.POCDMT000040Criterion
	 * @generated
	 */
	public Adapter createPOCDMT000040CriterionAdapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.hl7.v3.POCDMT000040Custodian <em>POCDMT000040 Custodian</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.hl7.v3.POCDMT000040Custodian
	 * @generated
	 */
	public Adapter createPOCDMT000040CustodianAdapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.hl7.v3.POCDMT000040CustodianOrganization <em>POCDMT000040 Custodian Organization</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.hl7.v3.POCDMT000040CustodianOrganization
	 * @generated
	 */
	public Adapter createPOCDMT000040CustodianOrganizationAdapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.hl7.v3.POCDMT000040DataEnterer <em>POCDMT000040 Data Enterer</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.hl7.v3.POCDMT000040DataEnterer
	 * @generated
	 */
	public Adapter createPOCDMT000040DataEntererAdapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.hl7.v3.POCDMT000040Device <em>POCDMT000040 Device</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.hl7.v3.POCDMT000040Device
	 * @generated
	 */
	public Adapter createPOCDMT000040DeviceAdapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.hl7.v3.POCDMT000040DocumentationOf <em>POCDMT000040 Documentation Of</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.hl7.v3.POCDMT000040DocumentationOf
	 * @generated
	 */
	public Adapter createPOCDMT000040DocumentationOfAdapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.hl7.v3.POCDMT000040EncompassingEncounter <em>POCDMT000040 Encompassing Encounter</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.hl7.v3.POCDMT000040EncompassingEncounter
	 * @generated
	 */
	public Adapter createPOCDMT000040EncompassingEncounterAdapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.hl7.v3.POCDMT000040Encounter <em>POCDMT000040 Encounter</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.hl7.v3.POCDMT000040Encounter
	 * @generated
	 */
	public Adapter createPOCDMT000040EncounterAdapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.hl7.v3.POCDMT000040EncounterParticipant <em>POCDMT000040 Encounter Participant</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.hl7.v3.POCDMT000040EncounterParticipant
	 * @generated
	 */
	public Adapter createPOCDMT000040EncounterParticipantAdapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.hl7.v3.POCDMT000040Entity <em>POCDMT000040 Entity</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.hl7.v3.POCDMT000040Entity
	 * @generated
	 */
	public Adapter createPOCDMT000040EntityAdapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.hl7.v3.POCDMT000040Entry <em>POCDMT000040 Entry</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.hl7.v3.POCDMT000040Entry
	 * @generated
	 */
	public Adapter createPOCDMT000040EntryAdapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.hl7.v3.POCDMT000040EntryRelationship <em>POCDMT000040 Entry Relationship</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.hl7.v3.POCDMT000040EntryRelationship
	 * @generated
	 */
	public Adapter createPOCDMT000040EntryRelationshipAdapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.hl7.v3.POCDMT000040ExternalAct <em>POCDMT000040 External Act</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.hl7.v3.POCDMT000040ExternalAct
	 * @generated
	 */
	public Adapter createPOCDMT000040ExternalActAdapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.hl7.v3.POCDMT000040ExternalDocument <em>POCDMT000040 External Document</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.hl7.v3.POCDMT000040ExternalDocument
	 * @generated
	 */
	public Adapter createPOCDMT000040ExternalDocumentAdapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.hl7.v3.POCDMT000040ExternalObservation <em>POCDMT000040 External Observation</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.hl7.v3.POCDMT000040ExternalObservation
	 * @generated
	 */
	public Adapter createPOCDMT000040ExternalObservationAdapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.hl7.v3.POCDMT000040ExternalProcedure <em>POCDMT000040 External Procedure</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.hl7.v3.POCDMT000040ExternalProcedure
	 * @generated
	 */
	public Adapter createPOCDMT000040ExternalProcedureAdapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.hl7.v3.POCDMT000040Guardian <em>POCDMT000040 Guardian</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.hl7.v3.POCDMT000040Guardian
	 * @generated
	 */
	public Adapter createPOCDMT000040GuardianAdapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.hl7.v3.POCDMT000040HealthCareFacility <em>POCDMT000040 Health Care Facility</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.hl7.v3.POCDMT000040HealthCareFacility
	 * @generated
	 */
	public Adapter createPOCDMT000040HealthCareFacilityAdapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.hl7.v3.POCDMT000040Informant12 <em>POCDMT000040 Informant12</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.hl7.v3.POCDMT000040Informant12
	 * @generated
	 */
	public Adapter createPOCDMT000040Informant12Adapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.hl7.v3.POCDMT000040InformationRecipient <em>POCDMT000040 Information Recipient</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.hl7.v3.POCDMT000040InformationRecipient
	 * @generated
	 */
	public Adapter createPOCDMT000040InformationRecipientAdapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.hl7.v3.POCDMT000040InfrastructureRootTypeId <em>POCDMT000040 Infrastructure Root Type Id</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.hl7.v3.POCDMT000040InfrastructureRootTypeId
	 * @generated
	 */
	public Adapter createPOCDMT000040InfrastructureRootTypeIdAdapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.hl7.v3.POCDMT000040InFulfillmentOf <em>POCDMT000040 In Fulfillment Of</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.hl7.v3.POCDMT000040InFulfillmentOf
	 * @generated
	 */
	public Adapter createPOCDMT000040InFulfillmentOfAdapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.hl7.v3.POCDMT000040IntendedRecipient <em>POCDMT000040 Intended Recipient</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.hl7.v3.POCDMT000040IntendedRecipient
	 * @generated
	 */
	public Adapter createPOCDMT000040IntendedRecipientAdapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.hl7.v3.POCDMT000040LabeledDrug <em>POCDMT000040 Labeled Drug</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.hl7.v3.POCDMT000040LabeledDrug
	 * @generated
	 */
	public Adapter createPOCDMT000040LabeledDrugAdapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.hl7.v3.POCDMT000040LanguageCommunication <em>POCDMT000040 Language Communication</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.hl7.v3.POCDMT000040LanguageCommunication
	 * @generated
	 */
	public Adapter createPOCDMT000040LanguageCommunicationAdapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.hl7.v3.POCDMT000040LegalAuthenticator <em>POCDMT000040 Legal Authenticator</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.hl7.v3.POCDMT000040LegalAuthenticator
	 * @generated
	 */
	public Adapter createPOCDMT000040LegalAuthenticatorAdapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.hl7.v3.POCDMT000040Location <em>POCDMT000040 Location</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.hl7.v3.POCDMT000040Location
	 * @generated
	 */
	public Adapter createPOCDMT000040LocationAdapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.hl7.v3.POCDMT000040MaintainedEntity <em>POCDMT000040 Maintained Entity</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.hl7.v3.POCDMT000040MaintainedEntity
	 * @generated
	 */
	public Adapter createPOCDMT000040MaintainedEntityAdapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.hl7.v3.POCDMT000040ManufacturedProduct <em>POCDMT000040 Manufactured Product</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.hl7.v3.POCDMT000040ManufacturedProduct
	 * @generated
	 */
	public Adapter createPOCDMT000040ManufacturedProductAdapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.hl7.v3.POCDMT000040Material <em>POCDMT000040 Material</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.hl7.v3.POCDMT000040Material
	 * @generated
	 */
	public Adapter createPOCDMT000040MaterialAdapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.hl7.v3.POCDMT000040NonXMLBody <em>POCDMT000040 Non XML Body</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.hl7.v3.POCDMT000040NonXMLBody
	 * @generated
	 */
	public Adapter createPOCDMT000040NonXMLBodyAdapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.hl7.v3.POCDMT000040Observation <em>POCDMT000040 Observation</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.hl7.v3.POCDMT000040Observation
	 * @generated
	 */
	public Adapter createPOCDMT000040ObservationAdapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.hl7.v3.POCDMT000040ObservationMedia <em>POCDMT000040 Observation Media</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.hl7.v3.POCDMT000040ObservationMedia
	 * @generated
	 */
	public Adapter createPOCDMT000040ObservationMediaAdapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.hl7.v3.POCDMT000040ObservationRange <em>POCDMT000040 Observation Range</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.hl7.v3.POCDMT000040ObservationRange
	 * @generated
	 */
	public Adapter createPOCDMT000040ObservationRangeAdapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.hl7.v3.POCDMT000040Order <em>POCDMT000040 Order</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.hl7.v3.POCDMT000040Order
	 * @generated
	 */
	public Adapter createPOCDMT000040OrderAdapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.hl7.v3.POCDMT000040Organization <em>POCDMT000040 Organization</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.hl7.v3.POCDMT000040Organization
	 * @generated
	 */
	public Adapter createPOCDMT000040OrganizationAdapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.hl7.v3.POCDMT000040OrganizationPartOf <em>POCDMT000040 Organization Part Of</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.hl7.v3.POCDMT000040OrganizationPartOf
	 * @generated
	 */
	public Adapter createPOCDMT000040OrganizationPartOfAdapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.hl7.v3.POCDMT000040Organizer <em>POCDMT000040 Organizer</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.hl7.v3.POCDMT000040Organizer
	 * @generated
	 */
	public Adapter createPOCDMT000040OrganizerAdapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.hl7.v3.POCDMT000040ParentDocument <em>POCDMT000040 Parent Document</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.hl7.v3.POCDMT000040ParentDocument
	 * @generated
	 */
	public Adapter createPOCDMT000040ParentDocumentAdapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.hl7.v3.POCDMT000040Participant1 <em>POCDMT000040 Participant1</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.hl7.v3.POCDMT000040Participant1
	 * @generated
	 */
	public Adapter createPOCDMT000040Participant1Adapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.hl7.v3.POCDMT000040Participant2 <em>POCDMT000040 Participant2</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.hl7.v3.POCDMT000040Participant2
	 * @generated
	 */
	public Adapter createPOCDMT000040Participant2Adapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.hl7.v3.POCDMT000040ParticipantRole <em>POCDMT000040 Participant Role</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.hl7.v3.POCDMT000040ParticipantRole
	 * @generated
	 */
	public Adapter createPOCDMT000040ParticipantRoleAdapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.hl7.v3.POCDMT000040Patient <em>POCDMT000040 Patient</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.hl7.v3.POCDMT000040Patient
	 * @generated
	 */
	public Adapter createPOCDMT000040PatientAdapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.hl7.v3.POCDMT000040PatientRole <em>POCDMT000040 Patient Role</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.hl7.v3.POCDMT000040PatientRole
	 * @generated
	 */
	public Adapter createPOCDMT000040PatientRoleAdapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.hl7.v3.POCDMT000040Performer1 <em>POCDMT000040 Performer1</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.hl7.v3.POCDMT000040Performer1
	 * @generated
	 */
	public Adapter createPOCDMT000040Performer1Adapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.hl7.v3.POCDMT000040Performer2 <em>POCDMT000040 Performer2</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.hl7.v3.POCDMT000040Performer2
	 * @generated
	 */
	public Adapter createPOCDMT000040Performer2Adapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.hl7.v3.POCDMT000040Person <em>POCDMT000040 Person</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.hl7.v3.POCDMT000040Person
	 * @generated
	 */
	public Adapter createPOCDMT000040PersonAdapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.hl7.v3.POCDMT000040Place <em>POCDMT000040 Place</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.hl7.v3.POCDMT000040Place
	 * @generated
	 */
	public Adapter createPOCDMT000040PlaceAdapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.hl7.v3.POCDMT000040PlayingEntity <em>POCDMT000040 Playing Entity</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.hl7.v3.POCDMT000040PlayingEntity
	 * @generated
	 */
	public Adapter createPOCDMT000040PlayingEntityAdapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.hl7.v3.POCDMT000040Precondition <em>POCDMT000040 Precondition</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.hl7.v3.POCDMT000040Precondition
	 * @generated
	 */
	public Adapter createPOCDMT000040PreconditionAdapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.hl7.v3.POCDMT000040Procedure <em>POCDMT000040 Procedure</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.hl7.v3.POCDMT000040Procedure
	 * @generated
	 */
	public Adapter createPOCDMT000040ProcedureAdapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.hl7.v3.POCDMT000040Product <em>POCDMT000040 Product</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.hl7.v3.POCDMT000040Product
	 * @generated
	 */
	public Adapter createPOCDMT000040ProductAdapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.hl7.v3.POCDMT000040RecordTarget <em>POCDMT000040 Record Target</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.hl7.v3.POCDMT000040RecordTarget
	 * @generated
	 */
	public Adapter createPOCDMT000040RecordTargetAdapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.hl7.v3.POCDMT000040Reference <em>POCDMT000040 Reference</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.hl7.v3.POCDMT000040Reference
	 * @generated
	 */
	public Adapter createPOCDMT000040ReferenceAdapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.hl7.v3.POCDMT000040ReferenceRange <em>POCDMT000040 Reference Range</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.hl7.v3.POCDMT000040ReferenceRange
	 * @generated
	 */
	public Adapter createPOCDMT000040ReferenceRangeAdapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.hl7.v3.POCDMT000040RegionOfInterest <em>POCDMT000040 Region Of Interest</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.hl7.v3.POCDMT000040RegionOfInterest
	 * @generated
	 */
	public Adapter createPOCDMT000040RegionOfInterestAdapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.hl7.v3.POCDMT000040RegionOfInterestValue <em>POCDMT000040 Region Of Interest Value</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.hl7.v3.POCDMT000040RegionOfInterestValue
	 * @generated
	 */
	public Adapter createPOCDMT000040RegionOfInterestValueAdapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.hl7.v3.POCDMT000040RelatedDocument <em>POCDMT000040 Related Document</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.hl7.v3.POCDMT000040RelatedDocument
	 * @generated
	 */
	public Adapter createPOCDMT000040RelatedDocumentAdapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.hl7.v3.POCDMT000040RelatedEntity <em>POCDMT000040 Related Entity</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.hl7.v3.POCDMT000040RelatedEntity
	 * @generated
	 */
	public Adapter createPOCDMT000040RelatedEntityAdapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.hl7.v3.POCDMT000040RelatedSubject <em>POCDMT000040 Related Subject</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.hl7.v3.POCDMT000040RelatedSubject
	 * @generated
	 */
	public Adapter createPOCDMT000040RelatedSubjectAdapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.hl7.v3.POCDMT000040ResponsibleParty <em>POCDMT000040 Responsible Party</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.hl7.v3.POCDMT000040ResponsibleParty
	 * @generated
	 */
	public Adapter createPOCDMT000040ResponsiblePartyAdapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.hl7.v3.POCDMT000040Section <em>POCDMT000040 Section</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.hl7.v3.POCDMT000040Section
	 * @generated
	 */
	public Adapter createPOCDMT000040SectionAdapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.hl7.v3.POCDMT000040ServiceEvent <em>POCDMT000040 Service Event</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.hl7.v3.POCDMT000040ServiceEvent
	 * @generated
	 */
	public Adapter createPOCDMT000040ServiceEventAdapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.hl7.v3.POCDMT000040Specimen <em>POCDMT000040 Specimen</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.hl7.v3.POCDMT000040Specimen
	 * @generated
	 */
	public Adapter createPOCDMT000040SpecimenAdapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.hl7.v3.POCDMT000040SpecimenRole <em>POCDMT000040 Specimen Role</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.hl7.v3.POCDMT000040SpecimenRole
	 * @generated
	 */
	public Adapter createPOCDMT000040SpecimenRoleAdapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.hl7.v3.POCDMT000040StructuredBody <em>POCDMT000040 Structured Body</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.hl7.v3.POCDMT000040StructuredBody
	 * @generated
	 */
	public Adapter createPOCDMT000040StructuredBodyAdapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.hl7.v3.POCDMT000040Subject <em>POCDMT000040 Subject</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.hl7.v3.POCDMT000040Subject
	 * @generated
	 */
	public Adapter createPOCDMT000040SubjectAdapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.hl7.v3.POCDMT000040SubjectPerson <em>POCDMT000040 Subject Person</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.hl7.v3.POCDMT000040SubjectPerson
	 * @generated
	 */
	public Adapter createPOCDMT000040SubjectPersonAdapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.hl7.v3.POCDMT000040SubstanceAdministration <em>POCDMT000040 Substance Administration</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.hl7.v3.POCDMT000040SubstanceAdministration
	 * @generated
	 */
	public Adapter createPOCDMT000040SubstanceAdministrationAdapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.hl7.v3.POCDMT000040Supply <em>POCDMT000040 Supply</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.hl7.v3.POCDMT000040Supply
	 * @generated
	 */
	public Adapter createPOCDMT000040SupplyAdapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.hl7.v3.PPDPQ <em>PPDPQ</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.hl7.v3.PPDPQ
	 * @generated
	 */
	public Adapter createPPDPQAdapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.hl7.v3.PPDTS <em>PPDTS</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.hl7.v3.PPDTS
	 * @generated
	 */
	public Adapter createPPDTSAdapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.hl7.v3.PQ <em>PQ</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.hl7.v3.PQ
	 * @generated
	 */
	public Adapter createPQAdapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.hl7.v3.PQR <em>PQR</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.hl7.v3.PQR
	 * @generated
	 */
	public Adapter createPQRAdapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.hl7.v3.QTY <em>QTY</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.hl7.v3.QTY
	 * @generated
	 */
	public Adapter createQTYAdapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.hl7.v3.REAL1 <em>REAL1</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.hl7.v3.REAL1
	 * @generated
	 */
	public Adapter createREAL1Adapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.hl7.v3.RTO <em>RTO</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.hl7.v3.RTO
	 * @generated
	 */
	public Adapter createRTOAdapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.hl7.v3.RTOMOPQ <em>RTOMOPQ</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.hl7.v3.RTOMOPQ
	 * @generated
	 */
	public Adapter createRTOMOPQAdapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.hl7.v3.RTOPQPQ <em>RTOPQPQ</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.hl7.v3.RTOPQPQ
	 * @generated
	 */
	public Adapter createRTOPQPQAdapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.hl7.v3.RTOQTYQTY <em>RTOQTYQTY</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.hl7.v3.RTOQTYQTY
	 * @generated
	 */
	public Adapter createRTOQTYQTYAdapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.hl7.v3.SC <em>SC</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.hl7.v3.SC
	 * @generated
	 */
	public Adapter createSCAdapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.hl7.v3.SLISTPQ <em>SLISTPQ</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.hl7.v3.SLISTPQ
	 * @generated
	 */
	public Adapter createSLISTPQAdapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.hl7.v3.SLISTTS <em>SLISTTS</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.hl7.v3.SLISTTS
	 * @generated
	 */
	public Adapter createSLISTTSAdapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.hl7.v3.ST1 <em>ST1</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.hl7.v3.ST1
	 * @generated
	 */
	public Adapter createST1Adapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.hl7.v3.StrucDocBr <em>Struc Doc Br</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.hl7.v3.StrucDocBr
	 * @generated
	 */
	public Adapter createStrucDocBrAdapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.hl7.v3.StrucDocCaption <em>Struc Doc Caption</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.hl7.v3.StrucDocCaption
	 * @generated
	 */
	public Adapter createStrucDocCaptionAdapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.hl7.v3.StrucDocCol <em>Struc Doc Col</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.hl7.v3.StrucDocCol
	 * @generated
	 */
	public Adapter createStrucDocColAdapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.hl7.v3.StrucDocColgroup <em>Struc Doc Colgroup</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.hl7.v3.StrucDocColgroup
	 * @generated
	 */
	public Adapter createStrucDocColgroupAdapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.hl7.v3.StrucDocContent <em>Struc Doc Content</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.hl7.v3.StrucDocContent
	 * @generated
	 */
	public Adapter createStrucDocContentAdapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.hl7.v3.StrucDocFootnote <em>Struc Doc Footnote</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.hl7.v3.StrucDocFootnote
	 * @generated
	 */
	public Adapter createStrucDocFootnoteAdapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.hl7.v3.StrucDocFootnoteRef <em>Struc Doc Footnote Ref</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.hl7.v3.StrucDocFootnoteRef
	 * @generated
	 */
	public Adapter createStrucDocFootnoteRefAdapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.hl7.v3.StrucDocItem <em>Struc Doc Item</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.hl7.v3.StrucDocItem
	 * @generated
	 */
	public Adapter createStrucDocItemAdapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.hl7.v3.StrucDocLinkHtml <em>Struc Doc Link Html</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.hl7.v3.StrucDocLinkHtml
	 * @generated
	 */
	public Adapter createStrucDocLinkHtmlAdapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.hl7.v3.StrucDocList <em>Struc Doc List</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.hl7.v3.StrucDocList
	 * @generated
	 */
	public Adapter createStrucDocListAdapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.hl7.v3.StrucDocParagraph <em>Struc Doc Paragraph</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.hl7.v3.StrucDocParagraph
	 * @generated
	 */
	public Adapter createStrucDocParagraphAdapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.hl7.v3.StrucDocRenderMultiMedia <em>Struc Doc Render Multi Media</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.hl7.v3.StrucDocRenderMultiMedia
	 * @generated
	 */
	public Adapter createStrucDocRenderMultiMediaAdapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.hl7.v3.StrucDocSub <em>Struc Doc Sub</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.hl7.v3.StrucDocSub
	 * @generated
	 */
	public Adapter createStrucDocSubAdapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.hl7.v3.StrucDocSup <em>Struc Doc Sup</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.hl7.v3.StrucDocSup
	 * @generated
	 */
	public Adapter createStrucDocSupAdapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.hl7.v3.StrucDocTable <em>Struc Doc Table</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.hl7.v3.StrucDocTable
	 * @generated
	 */
	public Adapter createStrucDocTableAdapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.hl7.v3.StrucDocTbody <em>Struc Doc Tbody</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.hl7.v3.StrucDocTbody
	 * @generated
	 */
	public Adapter createStrucDocTbodyAdapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.hl7.v3.StrucDocTd <em>Struc Doc Td</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.hl7.v3.StrucDocTd
	 * @generated
	 */
	public Adapter createStrucDocTdAdapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.hl7.v3.StrucDocText <em>Struc Doc Text</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.hl7.v3.StrucDocText
	 * @generated
	 */
	public Adapter createStrucDocTextAdapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.hl7.v3.StrucDocTfoot <em>Struc Doc Tfoot</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.hl7.v3.StrucDocTfoot
	 * @generated
	 */
	public Adapter createStrucDocTfootAdapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.hl7.v3.StrucDocTh <em>Struc Doc Th</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.hl7.v3.StrucDocTh
	 * @generated
	 */
	public Adapter createStrucDocThAdapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.hl7.v3.StrucDocThead <em>Struc Doc Thead</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.hl7.v3.StrucDocThead
	 * @generated
	 */
	public Adapter createStrucDocTheadAdapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.hl7.v3.StrucDocTitle <em>Struc Doc Title</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.hl7.v3.StrucDocTitle
	 * @generated
	 */
	public Adapter createStrucDocTitleAdapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.hl7.v3.StrucDocTitleContent <em>Struc Doc Title Content</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.hl7.v3.StrucDocTitleContent
	 * @generated
	 */
	public Adapter createStrucDocTitleContentAdapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.hl7.v3.StrucDocTitleFootnote <em>Struc Doc Title Footnote</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.hl7.v3.StrucDocTitleFootnote
	 * @generated
	 */
	public Adapter createStrucDocTitleFootnoteAdapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.hl7.v3.StrucDocTr <em>Struc Doc Tr</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.hl7.v3.StrucDocTr
	 * @generated
	 */
	public Adapter createStrucDocTrAdapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.hl7.v3.SXCMCD <em>SXCMCD</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.hl7.v3.SXCMCD
	 * @generated
	 */
	public Adapter createSXCMCDAdapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.hl7.v3.SXCMINT <em>SXCMINT</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.hl7.v3.SXCMINT
	 * @generated
	 */
	public Adapter createSXCMINTAdapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.hl7.v3.SXCMMO <em>SXCMMO</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.hl7.v3.SXCMMO
	 * @generated
	 */
	public Adapter createSXCMMOAdapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.hl7.v3.SXCMPPDPQ <em>SXCMPPDPQ</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.hl7.v3.SXCMPPDPQ
	 * @generated
	 */
	public Adapter createSXCMPPDPQAdapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.hl7.v3.SXCMPPDTS <em>SXCMPPDTS</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.hl7.v3.SXCMPPDTS
	 * @generated
	 */
	public Adapter createSXCMPPDTSAdapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.hl7.v3.SXCMPQ <em>SXCMPQ</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.hl7.v3.SXCMPQ
	 * @generated
	 */
	public Adapter createSXCMPQAdapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.hl7.v3.SXCMREAL <em>SXCMREAL</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.hl7.v3.SXCMREAL
	 * @generated
	 */
	public Adapter createSXCMREALAdapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.hl7.v3.SXCMTS <em>SXCMTS</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.hl7.v3.SXCMTS
	 * @generated
	 */
	public Adapter createSXCMTSAdapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.hl7.v3.SXPRTS <em>SXPRTS</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.hl7.v3.SXPRTS
	 * @generated
	 */
	public Adapter createSXPRTSAdapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.hl7.v3.TEL <em>TEL</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.hl7.v3.TEL
	 * @generated
	 */
	public Adapter createTELAdapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.hl7.v3.Thumbnail <em>Thumbnail</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.hl7.v3.Thumbnail
	 * @generated
	 */
	public Adapter createThumbnailAdapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.hl7.v3.TN <em>TN</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.hl7.v3.TN
	 * @generated
	 */
	public Adapter createTNAdapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.hl7.v3.TS1 <em>TS1</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.hl7.v3.TS1
	 * @generated
	 */
	public Adapter createTS1Adapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.hl7.v3.URL1 <em>URL1</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.hl7.v3.URL1
	 * @generated
	 */
	public Adapter createURL1Adapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.hl7.v3.UVPTS <em>UVPTS</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.hl7.v3.UVPTS
	 * @generated
	 */
	public Adapter createUVPTSAdapter() {
		return null;
	}

	/**
	 * Creates a new adapter for the default case.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @generated
	 */
	public Adapter createEObjectAdapter() {
		return null;
	}

} //V3AdapterFactory
